/*
  作者：不正经绣才
  日期：2025.8.26
*/
const app = getApp();
const { logInfo, logWarn, logError } = require('../../utils/log.js');

Page({
  data: {
    navHeight: 44, // 导航栏高度
    statusBarHeight: 20, // 状态栏高度
    capsuleButtonInfo: null, // 胶囊按钮信息
    version: '1.0.0',
    showHistoryModal: false,
    historyList: [],
    // 用户信息
    userAvatar: '/images/personal.png', // 默认头像使用项目中的图标
    userNickname: '幸运用户（可修改）',
    showNicknameModal: false,
    editNickname: '',
    isComposition: false, // 标记是否处于输入法组合状态
    // 设置弹窗相关
    showSettingsModal: false,
    soundEnabled: true, // 工具声音开关
    vibrateEnabled: false, // 工具振动开关
    spinDuration: 3, // 转盘转动时间（秒）
    // 幸运等级系统
    luckyLevel: 0,
    luckyExp: 0,
    levelExpRequirements: [10, 50, 100, 500, 1000, 2000, 5000, 10000], // LV1-LV8升级所需经验，LV8为最高等级
    expProgressWidth: '0%', // 经验条宽度
    // 成就和称号系统
    achievements: ['初学小白', '小试牛刀', '初窥门径', '略有小成', '驾轻就熟', '心领神会', '融会贯通', '炉火纯青', '登峰造极'], // LV0-LV8对应称号
    currentTitle: '初学小白', // 当前佩戴的称号
    showAchievementModal: false, // 成就弹窗显示状态
    showToolHelpModal: false, // 工具帮助弹窗显示状态
    // 登录奖励系统
    lastLoginDate: '',
    consecutiveLoginDays: 0,
    hasSpinToday: false,
    // 新增弹窗状态
    showVersionModal: false,
    showExchangeModal: false,
    gongde: 0, // 当前功德值
    // 版本历史记录，更新版本时在最前面添加
    versionHistory: [
      {
        version: 'v1.2.2',
        date: '2025-11-2',
        description: '1. 优化转盘样式\n2. 调整转盘圈数和默认时长'
      },
      {
        version: 'v1.2.1',
        date: '2025-10-15',
        description: '1. 去除转盘背景\n2. 调整个人中心按钮布局\n3. 转盘列表和个人中心增加了广告展示'
      },
      {
        version: 'v1.2.0',
        date: '2025-09-21',
        description: '1. 首页修改为响应式布局，适应不同分辨率\n2. 调整转盘样式及实时结果显示逻辑\n3. 优化热门转盘'
      },
      {
        version: 'v1.1.0',
        date: '2025-09-17',
        description: '1. 增加客服\n2. 优化快速创建\n3. 修复无法显示Unicode表情的bug'
      },
      {
        version: 'v1.0.0',
        date: '2025-09-10',
        description: '1. 转盘基本功能实现\n2. 支持多模式工具\n3. 完善个人中心'
      }
    ],
    // 模式切换确认弹窗相关
    showModeConfirmModal: false,
    currentModeName: '',
    currentModeIcon: '',
    currentModeIconClass: '',
    currentModeDescription: '',
    currentModeHelp: '',
    currentModeIndex: 0,
    // 添加不再提示选项
    hideModeConfirm: false,
    // 各个工具的功能介绍
    toolDescriptions: [
      {
        name: '转盘',
        icon: '🎯',
        iconClass: 'wheel-icon',
        description: '经典的转盘决策工具，创建自定义选项转盘，随机选择结果帮助你做决定。'
      },
      {
        name: '翻牌子',
        icon: '🃏',
        iconClass: 'cards-icon',
        description: '翻牌子决策工具，根据首页选择的转盘创建多个卡牌，随机翻开一张卡牌作为结果。'
      },
      {
        name: '幸运抽签',
        icon: '📜',
        iconClass: 'fortune-icon',
        description: '幸运抽签决策工具，根据首页选择的转盘创建多个签，从签筒中随机抽取一支签作为结果。',
      },
      {
        name: '抛硬币',
        icon: '🪙',
        iconClass: 'coin-icon',
        description: '经典的抛硬币决策工具，随机选择正反面，帮助解决二选一的难题。'
      },
      {
        name: '减压敲',
        icon: '🪘',
        iconClass: 'muyu-icon',
        description: '减压工具，模拟敲击木鱼的过程，帮助放松心情，积累功德值。'
      },
      {
        name: '手持弹幕',
        icon: '💬',
        iconClass: 'bullet-icon',
        description: '手持弹幕工具，可以自定义弹幕内容，在屏幕上滚动显示。'
      }
    ]
  },

  onLoad() {
    // 加载历史记录
    this.loadHistory();
    // 初始化用户数据
    this.initUserData();
    // 检查登录奖励
    this.checkDailyLogin();
    
    // 调试：检查所有模式的"不再提示"设置
    this.testHideConfirmSettings();
  },

  onShow() {
    // 页面切换时重新加载数据
    logInfo('个人中心页面onShow - 开始刷新数据');
    
    // 重新加载历史记录（可能有新的转盘记录）
    this.loadHistory();
    
    // 重新初始化用户数据（确保等级和经验是最新的）
    this.initUserData();
    
    // 检查是否有新的登录奖励（如果从其他页面返回且日期发生变化）
    this.checkDailyLogin();
    
    logInfo('个人中心页面onShow - 刷新完成');
  },

  // 显示历史记录弹窗
  showHistory() {
    this.loadHistory();
    this.setData({
      showHistoryModal: true
    });
  },

  // 隐藏历史记录弹窗
  hideHistory() {
    this.setData({
      showHistoryModal: false
    });
  },

  // 加载历史记录
  loadHistory() {
    try {
      const history = wx.getStorageSync('gameHistory') || [];
      this.setData({
        historyList: history
      });
    } catch (e) {
      logError('加载历史记录失败', e);
      this.setData({
        historyList: []
      });
    }
  },

  // 初始化用户数据
  initUserData() {
    try {
      // 加载头像
      const avatar = wx.getStorageSync('userAvatar');
      if (avatar) {
        this.setData({ userAvatar: avatar });
      }
      
      // 加载昵称
      const nickname = wx.getStorageSync('userNickname');
      if (nickname) {
        this.setData({ userNickname: nickname });
      }
      
      // 加载设置项
      const app = getApp();
      
      // 从本地存储加载设置，如果不存在则使用全局默认值
      let soundEnabled = wx.getStorageSync('soundEnabled');
      if (soundEnabled === '') soundEnabled = app.globalData.soundEnabled;
      
      let vibrateEnabled = wx.getStorageSync('vibrateEnabled');
      if (vibrateEnabled === '') vibrateEnabled = app.globalData.vibrateEnabled;
      
      let spinDuration = wx.getStorageSync('spinDuration');
      if (spinDuration === '') spinDuration = app.globalData.spinDuration;
      
      this.setData({
        soundEnabled: soundEnabled !== undefined ? soundEnabled : true,
        vibrateEnabled: vibrateEnabled !== undefined ? vibrateEnabled : false,
        spinDuration: spinDuration || 3
      });
      
      // 同步到全局数据
      app.globalData.soundEnabled = this.data.soundEnabled;
      app.globalData.vibrateEnabled = this.data.vibrateEnabled;
      app.globalData.spinDuration = this.data.spinDuration;
      
      // 加载幸运等级数据
      const luckyLevel = wx.getStorageSync('luckyLevel') || 0;
      const luckyExp = wx.getStorageSync('luckyExp') || 0;
      
      // 加载当前称号，默认为第一个成就称号
      const currentTitle = wx.getStorageSync('currentTitle') || this.data.achievements[0];
      
      this.setData({ luckyLevel, luckyExp, currentTitle });
      
      // 更新经验条宽度
      this.updateExpProgressWidth();
      
      // 加载登录数据
      const lastLoginDate = wx.getStorageSync('lastLoginDate') || '';
      const consecutiveLoginDays = wx.getStorageSync('consecutiveLoginDays') || 0;
      const hasSpinToday = wx.getStorageSync('hasSpinToday') || false;
      
      // 加载功德值
      const gongde = wx.getStorageSync('gongde') || 0;
      
      this.setData({ lastLoginDate, consecutiveLoginDays, hasSpinToday, gongde });
    } catch (e) {
      logError('初始化用户数据失败', e);
    }
  },

  // 选择头像
  chooseAvatar() {
    wx.chooseImage({
      count: 1,
      sizeType: ['compressed'],
      sourceType: ['album', 'camera'],
      success: (res) => {
        const tempFilePath = res.tempFilePaths[0];
        this.setData({ userAvatar: tempFilePath });
        wx.setStorageSync('userAvatar', tempFilePath);
        wx.showToast({
          title: '头像更新成功',
          icon: 'success'
        });
      },
      fail: (err) => {
        logError('选择头像失败', err);
      }
    });
  },

  // 开始编辑昵称
  startEditNickname() {
    this.setData({
      showNicknameModal: true,
      editNickname: this.data.userNickname
    });
  },

  // 昵称输入变化
  onNicknameInput(e) {
    this.setData({
      editNickname: e.detail.value
    });
  },

  // 输入法组合开始事件
  onCompositionStart() {
    this.setData({
      isComposition: true
    });
  },

  // 输入法组合结束事件
  onCompositionEnd(e) {
    this.setData({
      isComposition: false,
      editNickname: e.detail.value
    });
  },

  // 确认修改昵称
  confirmNickname() {
    // 如果处于输入法组合状态，不进行验证
    if (this.data.isComposition) {
      // 在输入法组合状态下，延迟一段时间后再次尝试验证
      setTimeout(() => {
        if (!this.data.isComposition) {
          this.confirmNickname();
        }
      }, 100);
      return;
    }

    // 检查昵称是否为空
    if (!this.data.editNickname || this.data.editNickname.length === 0) {
      wx.showToast({
        title: '昵称不能为空',
        icon: 'none'
      });
      return;
    }

    // 去除首尾空格后再检查是否为空
    const trimmedNickname = this.data.editNickname.trim();
    if (trimmedNickname.length === 0) {
      wx.showToast({
        title: '昵称不能为空',
        icon: 'none'
      });
      return;
    }
    
    // 限制昵称长度不超过10个字符（一个中文字符也按一个字符计算）
    if (this.data.editNickname.length > 10) {
      wx.showToast({
        title: '昵称不能超过10个字符',
        icon: 'none'
      });
      return;
    }
    
    this.setData({
      userNickname: trimmedNickname,
      showNicknameModal: false
    });
    wx.setStorageSync('userNickname', trimmedNickname);
    wx.showToast({
      title: '昵称修改成功',
      icon: 'success'
    });
  },

  // 取消编辑昵称
  cancelEditNickname() {
    this.setData({
      showNicknameModal: false,
      editNickname: ''
    });
  },

  // 检查每日登录奖励
  checkDailyLogin() {
    const today = this.getToday();
    const lastLoginDate = this.data.lastLoginDate;
    
    if (lastLoginDate !== today) {
      // 今天首次登录
      let consecutiveDays = this.data.consecutiveLoginDays;
      let expBonus = 1; // 基础奖励
      
      if (this.isConsecutiveDay(lastLoginDate, today)) {
        // 连续登录
        consecutiveDays += 1;
        expBonus = Math.min(consecutiveDays, 7); // 最多+7
      } else {
        // 非连续登录，重置
        consecutiveDays = 1;
        expBonus = 1;
      }
      
      this.addLuckyExp(expBonus);
      this.setData({ 
        lastLoginDate: today, 
        consecutiveLoginDays: consecutiveDays,
        hasSpinToday: false // 重置今日转盘状态
      });
      wx.setStorageSync('lastLoginDate', today);
      wx.setStorageSync('consecutiveLoginDays', consecutiveDays);
      wx.setStorageSync('hasSpinToday', false);
      
      // 重置所有模式的每日状态
      wx.setStorageSync('hasCoinToday', false);
      wx.setStorageSync('hasCardsToday', false);
      wx.setStorageSync('hasMuyuToday', false);
      wx.setStorageSync('hasFortuneToday', false);
      
      // 延迟显示登录奖励提示，避免与其他提示冲突
      setTimeout(() => {
        wx.showToast({
          title: `登录奖励+${expBonus}经验`,
          icon: 'success',
          duration: 1000
        });
      }, 800);
    }
  },

  // 转盘奖励（从主页调用）
  addSpinReward() {
    if (!this.data.hasSpinToday) {
      this.addLuckyExp(1);
      this.setData({ hasSpinToday: true });
      wx.setStorageSync('hasSpinToday', true);
      wx.showToast({
        title: '首次转盘+1经验',
        icon: 'success',
        duration: 1000
      });
    }
  },

  // 增加幸运经验
  addLuckyExp(exp) {
    let { luckyLevel, luckyExp } = this.data;
    luckyExp += exp;
    
    // 检查是否升级（最高等级为LV8）
    while (luckyLevel < 8 && luckyExp >= this.data.levelExpRequirements[luckyLevel]) {
      luckyExp -= this.data.levelExpRequirements[luckyLevel];
      luckyLevel += 1;
      wx.showToast({
        title: `恭喜升级到LV${luckyLevel}!`,
        icon: 'success'
      });
    }
    
    this.setData({ luckyLevel, luckyExp });
    wx.setStorageSync('luckyLevel', luckyLevel);
    wx.setStorageSync('luckyExp', luckyExp);
    
    // 更新经验条宽度
    this.updateExpProgressWidth();
  },

  // 获取今天日期字符串
  getToday() {
    const now = new Date();
    return `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-${String(now.getDate()).padStart(2, '0')}`;
  },

  // 更新经验条宽度
  updateExpProgressWidth() {
    const expWidth = this.getExpProgressWidth();
    this.setData({ expProgressWidth: expWidth });
  },

  // 计算经验条宽度百分比
  getExpProgressWidth() {
    const { luckyLevel, luckyExp, levelExpRequirements } = this.data;
    if (luckyLevel >= 8) {
      return '100%';
    }
    const percentage = (luckyExp / levelExpRequirements[luckyLevel] * 100);
    return `${percentage}%`;
  },

  // 判断是否连续登录
  isConsecutiveDay(lastDate, currentDate) {
    if (!lastDate) return false;
    
    const last = new Date(lastDate);
    const current = new Date(currentDate);
    const diffTime = current.getTime() - last.getTime();
    const diffDays = Math.ceil(diffTime / (1000 * 60 * 60 * 24));
    
    return diffDays === 1;
  },

  // 测试方法：检查并显示所有模式的"不再提示"设置
  testHideConfirmSettings() {
    logInfo("开始检查所有模式的'不再提示'设置");
    for (let i = 0; i <= 5; i++) {
      const hideConfirmKey = `hideModeConfirm_${i}`;
      const value = wx.getStorageSync(hideConfirmKey);
      logInfo(`模式${i}的'不再提示'设置: key=${hideConfirmKey}, value=${value}, type=${typeof value}`);
    }
  },

  // 处理模式按钮点击（直接跳转，不再显示确认弹窗）
  handleModeButtonTap(e) {
    const { mode, name } = e.currentTarget.dataset;
    const modeIndex = parseInt(mode);
    
    logInfo(`直接切换到${name}模式，索引：${modeIndex}`);
    
    // 将目标模式保存到全局数据
    app.globalData.targetMode = modeIndex;
    app.globalData.targetModeName = name;
    
    logInfo(`设置全局数据: targetMode=${modeIndex}, targetModeName=${name}`);
    
    // 跳转到首页
    logInfo(`开始跳转到首页`);
    wx.switchTab({
      url: '/pages/index/index'
    });
  },

  // 跳转到首页指定模式（修改为直接跳转）
  jumpToMode(e) {
    this.handleModeButtonTap(e);
  },

  // 通用历史记录保存方法（供其他页面调用）
  saveGameHistory(mode, name, result) {
    try {
      const icons = {
        'wheel': '🎯',
        'coin': '🪙',
        'cards': '🌏',
        'fortune': '📜'
      };
      
      const historyItem = {
        mode: mode,
        icon: icons[mode] || '🎯',
        name: name,
        result: result,
        time: new Date().toLocaleString()
      };
      
      let history = wx.getStorageSync('gameHistory') || [];
      history.unshift(historyItem);
      
      // 最多保存50条记录
      if (history.length > 50) {
        history = history.slice(0, 50);
      }
      
      wx.setStorageSync('gameHistory', history);
      logInfo('历史记录保存成功:', historyItem);
    } catch (e) {
      logError('保存历史记录失败', e);
    }
  },

  // 新增的功能按钮处理方法
  openSettings() {
    this.setData({
      showSettingsModal: true
    });
  },

  closeSettings() {
    this.setData({
      showSettingsModal: false
    });
  },

  // 声音开关变化
  onSoundChange(e) {
    const enabled = e.detail.value;
    this.setData({ soundEnabled: enabled });
    
    // 同步到全局数据
    const app = getApp();
    app.globalData.soundEnabled = enabled;
    
    // 持久化存储
    try {
      wx.setStorageSync('soundEnabled', enabled);
    } catch (e) {
      logError('保存声音设置失败', e);
    }
    
    wx.showToast({
      title: `声音已${enabled ? '开启' : '关闭'}`,
      icon: 'success',
      duration: 1000
    });
  },

  // 振动开关变化
  onVibrateChange(e) {
    const enabled = e.detail.value;
    this.setData({ vibrateEnabled: enabled });
    
    // 同步到全局数据
    const app = getApp();
    app.globalData.vibrateEnabled = enabled;
    
    // 持久化存储
    try {
      wx.setStorageSync('vibrateEnabled', enabled);
    } catch (e) {
      logError('保存振动设置失败', e);
    }
    
    wx.showToast({
      title: `振动已${enabled ? '开启' : '关闭'}`,
      icon: 'success',
      duration: 1000
    });
  },

  // 设置转盘转动时间
  setSpinDuration() {
    wx.showModal({
      title: '设置转动时间',
      // content: `当前转动时间：${this.data.spinDuration}秒\n请输入 3-5 秒之间的数值`,
      editable: true,
      placeholderText: '请输入 3-5 之间的数值',
      success: (res) => {
        if (res.confirm && res.content) {
          const duration = parseFloat(res.content);
          
          // 验证输入值
          if (isNaN(duration)) {
            wx.showToast({
              title: '请输入有效数字',
              icon: 'none',
              duration: 1500
            });
            return;
          }
          
          if (duration < 3 || duration > 5) {
            wx.showToast({
              title: '转动时间必须在 3-5 秒之间',
              icon: 'none',
              duration: 1500
            });
            return;
          }
          
          // 保留一位小数
          const validDuration = Math.round(duration * 10) / 10;
          
          this.setData({ spinDuration: validDuration });
          
          // 同步到全局数据
          const app = getApp();
          app.globalData.spinDuration = validDuration;
          
          // 持久化存储
          try {
            wx.setStorageSync('spinDuration', validDuration);
          } catch (e) {
            logError('保存转动时间设置失败', e);
          }
          
          wx.showToast({
            title: `转动时间已设置为 ${validDuration} 秒`,
            icon: 'success',
            duration: 1500
          });
        }
      }
    });
  },

  openAchievements() {
    this.setData({
      showAchievementModal: true
    });
  },

  openExchange() {
    // 加载功德值
    const gongde = wx.getStorageSync('gongde') || 0;
    this.setData({ gongde });
    
    this.setData({
      showExchangeModal: true
    });
  },

  // 隐藏兑换弹窗
  hideExchange() {
    this.setData({
      showExchangeModal: false
    });
  },

  // 执行兑换操作
  performExchange(e) {
    const { type } = e.currentTarget.dataset;
    const today = this.getToday();
    
    // 检查今日兑换状态
    const lastExchangeDate = wx.getStorageSync('lastExchangeDate') || '';
    const hasExchangedToday = lastExchangeDate === today;
    
    if (hasExchangedToday) {
      wx.showToast({
        title: '今日已兑换过，请明天再来',
        icon: 'none',
        duration: 1500
      });
      return;
    }
    
    // 获取当前功德值
    const currentGongde = wx.getStorageSync('gongde') || 0;
    
    let requiredGongde = 0;
    let gainedExp = 0;
    let exchangeText = '';
    
    if (type === 'small') {
      requiredGongde = 10;
      gainedExp = 10;
      exchangeText = '消耗10点功德，获得10点经验';
    } else if (type === 'large') {
      requiredGongde = 100;
      gainedExp = 100;
      exchangeText = '消耗100点功德，获得100点经验';
    }
    
    // 检查功德是否足够
    if (currentGongde < requiredGongde) {
      wx.showToast({
        title: `功德不足，需要${requiredGongde}点功德`,
        icon: 'none',
        duration: 1500
      });
      return;
    }
    
    // 确认兑换
    wx.showModal({
      title: '确认兑换',
      content: `${exchangeText}\n\n当前功德：${currentGongde}点\n兑换后功德：${currentGongde - requiredGongde}点`,
      success: (res) => {
        if (res.confirm) {
          // 执行兑换
          const newGongde = currentGongde - requiredGongde;
          
          // 更新功德值
          wx.setStorageSync('gongde', newGongde);
          this.setData({ gongde: newGongde });
          
          // 增加经验
          this.addLuckyExp(gainedExp);
          
          // 记录今日已兑换
          wx.setStorageSync('lastExchangeDate', today);
          
          wx.showToast({
            title: `兑换成功！获得${gainedExp}点经验`,
            icon: 'success',
            duration: 1500
          });
          
          // 关闭兑换弹窗
          this.hideExchange();
        }
      }
    });
  },

  // 获取今天日期字符串
  getToday() {
    const now = new Date();
    return `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-${String(now.getDate()).padStart(2, '0')}`;
  },

  // 处理导航栏高度变化事件
  onNavHeightChange: function(e) {
    const navHeight = e.detail.navHeight;
    const statusBarHeight = e.detail.statusBarHeight;
    const capsuleButtonInfo = e.detail.capsuleButtonInfo;
    
    this.setData({
      navHeight: navHeight,
      statusBarHeight: statusBarHeight,
      capsuleButtonInfo: capsuleButtonInfo
    });
    
    // 更新页面布局样式
    this.updatePageLayout(navHeight, statusBarHeight, capsuleButtonInfo);
  },

  // 更新页面布局样式
  updatePageLayout: function(navHeight, statusBarHeight, capsuleButtonInfo) {
    // 这里可以添加任何需要根据导航栏高度调整的布局逻辑
    logInfo('导航栏高度更新为:', navHeight);
    logInfo('状态栏高度:', statusBarHeight);
    logInfo('胶囊按钮信息:', capsuleButtonInfo);
  },

  // 复制到剪贴板
  copyToClipboard(e) {
    const content = e.currentTarget.dataset.content;
    wx.setClipboardData({
      data: content,
      success: () => {
        wx.showToast({
          title: '已复制到剪贴板',
          icon: 'success',
          duration: 1500
        });
      },
      fail: (err) => {
        logError('复制失败', err);
        wx.showToast({
          title: '复制失败',
          icon: 'none',
          duration: 1500
        });
      }
    });
  },

  // 显示工具帮助弹窗
  showToolHelp() {
    this.setData({
      showToolHelpModal: true
    });
  },

  // 隐藏工具帮助弹窗
  hideToolHelp() {
    this.setData({
      showToolHelpModal: false
    });
  },

  // 显示版本信息弹窗
  showVersionInfo() {
    this.setData({
      showVersionModal: true
    });
  },

  // 隐藏版本信息弹窗
  hideVersionInfo() {
    this.setData({
      showVersionModal: false
    });
  },

  // 隐藏成就弹窗
  hideAchievement() {
    this.setData({
      showAchievementModal: false
    });
  },

  // 选择称号
  selectTitle(e) {
    const { index } = e.currentTarget.dataset;
    const selectedTitle = this.data.achievements[index];
    const requiredLevel = index;
    
    // 检查是否达到等级要求
    if (this.data.luckyLevel < requiredLevel) {
      wx.showToast({
        title: `需要达到LV${requiredLevel}才能佩戴此称号`,
        icon: 'none',
        duration: 1500
      });
      return;
    }
    
    // 佩戴称号
    this.setData({ currentTitle: selectedTitle });
    wx.setStorageSync('currentTitle', selectedTitle);
    
    wx.showToast({
      title: `已佩戴称号：${selectedTitle}`,
      icon: 'success',
      duration: 1500
    });
    
    // 关闭弹窗
    this.hideAchievement();
  },

  // 跳转到手持弹幕页面
  navigateToBullet() {
    wx.navigateTo({
      url: '/pages/bullet/bullet'
    });
  },
  
  // 配置分享给好友
  onShareAppMessage() {
    return {
      title: '小幸运转盘',
      path: '/pages/index/index',
      imageUrl: '',
      success: (res) => {
        wx.showToast({
          title: '分享成功',
          icon: 'success',
          duration: 1000
        });
      },
      fail: (res) => {
        wx.showToast({
          title: '分享失败',
          icon: 'none',
          duration: 1000
        });
      }
    }
  },
  
  // 配置分享到朋友圈
  onShareTimeline() {
    return {
      title: '小幸运转盘',
      query: 'page=index',
      imageUrl: ''
    }
  },

  // 广告日志打印
  adLoad() {
    logInfo('原生模板广告加载成功')
  },

  adError(err) {
    logError('原生模板广告加载失败', err)
  },

  adClose() {
    logInfo('原生模板广告关闭')
  },
});